import { sql } from "kysely";
import { defineConfig } from "kysely-codegen";
import pluralize from "pluralize";

export default defineConfig({
  camelCase: false,
  dateParser: "timestamp",
  dialect: "postgres",
  excludePattern: "(graphile_migrate.*|graphile_worker._private_*)",
  outFile: "./types/database-types.ts",
  postprocess: async ({ db, metadata }) => {
    const rows = await db
      .selectFrom("pg_catalog.pg_constraint as foreign_key_constraint")
      .innerJoin(
        "pg_catalog.pg_class as from_table",
        "from_table.oid",
        "foreign_key_constraint.conrelid",
      )
      .innerJoin(
        "pg_catalog.pg_namespace as from_table_namespace",
        "from_table_namespace.oid",
        "from_table.relnamespace",
      )
      .innerJoin("pg_catalog.pg_attribute as from_column", (join) =>
        join
          .onRef("from_column.attrelid", "=", "from_table.oid")
          .on(sql`from_column.attnum = any(foreign_key_constraint.conkey)`),
      )
      .innerJoin(
        "pg_catalog.pg_class as to_table",
        "to_table.oid",
        "foreign_key_constraint.confrelid",
      )
      .innerJoin(
        "pg_catalog.pg_namespace as to_table_namespace",
        "to_table_namespace.oid",
        "to_table.relnamespace",
      )
      .innerJoin("pg_catalog.pg_attribute as to_column", (join) =>
        join
          .onRef("to_column.attrelid", "=", "to_table.oid")
          .on(sql`to_column.attnum = any(foreign_key_constraint.confkey)`),
      )
      .select([
        "from_table_namespace.nspname as fromSchema",
        "from_table.relname as fromTable",
        "from_column.attname as fromColumn",
        "to_table_namespace.nspname as enumSchema",
        "to_table.relname as enumTable",
        "to_column.attname as enumColumn",
      ])
      .where("foreign_key_constraint.contype", "=", "f")
      .where(sql<any>`obj_description(to_table.oid, 'pg_class') like '%@&#8203;enum%'`)
      .execute();

    await Promise.all(
      rows.map(
        async ({
          fromColumn,
          fromSchema,
          fromTable,
          enumColumn,
          enumSchema,
          enumTable,
        }) => {
          const fromTableMetadata = metadata.tables.find(
            (table) => table.schema === fromSchema && table.name === fromTable,
          );
          const fromColumnMetadata = fromTableMetadata?.columns.find(
            (column) => column.name === fromColumn,
          );
          const enumTableMetadata = metadata.tables.find(
            (table) => table.schema === enumSchema && table.name === enumTable,
          );
          const enumColumnMetadata = enumTableMetadata?.columns.find(
            (column) => column.name === enumColumn,
          );

          if (fromColumnMetadata || enumColumnMetadata) {
            const dataType = `${pluralize.singular(enumTable)}.${enumColumn}`;
            const enumValues = await db
              .selectFrom(`${enumSchema}.${enumTable}`)
              .select(enumColumn)
              .execute()
              .then((rows) =>
                rows.map((row) => (row as Record<string, string>)[enumColumn]),
              );

            metadata.enums.set(`${enumSchema}.${dataType}`, enumValues);

            if (fromColumnMetadata) {
              fromColumnMetadata.dataTypeSchema = enumSchema;
              fromColumnMetadata.dataType = dataType;
            }

            if (enumColumnMetadata) {
              enumColumnMetadata.dataTypeSchema = enumSchema;
              enumColumnMetadata.dataType = dataType;
            }
          }
        },
      ),
    );

    return metadata;
  },
  singularize: true,
  url: process.env.DATABASE_URL,
});

import type { InstantRange } from './custom-types';
import type { Duration as CustomDuration } from '@​my-org/custom-types';
import type { Temporal } from '@​js-temporal/polyfill';

export interface EventModel {
  createdAt: Temporal.Instant;
  dateRange: ColumnType<InstantRange, InstantRange, never>;
  eventDate: Temporal.PlainDate;
  interval: CustomDuration;
}

export interface DB {
  events: EventModel;
}